home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 58189 / 58189.xpi / components / CsFire.js
Text File  |  2010-01-07  |  6KB  |  203 lines
  1. /*
  2.  * This service is the main component of the CsFire extension. It defines
  3.  * all the required hooks to handle browser events. All the extension-specific
  4.  * code is contained elsewhere (probably CsFireController).
  5.  */
  6.  
  7. Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
  8.  
  9. // constants: shorter version
  10. const CI = Components.interfaces;
  11. const CC = Components.classes;
  12. const CICP = CI.nsIContentPolicy;
  13.  
  14.  
  15. /*
  16.  * Defines a new CsFire service, in a separate namespace, to avoid
  17.  * variable pollution.
  18.  */
  19.  
  20. CsFireService = function() {};
  21. CsFireService.prototype = {
  22.     classDescription: "Main component of the CsFire extension",
  23.     classID:          Components.ID("{b6e72cf8-8cb7-4706-9582-985a09db5a2b}"),
  24.     contractID:       "@cs.kuleuven.be/csfire;1",
  25.     QueryInterface :   XPCOMUtils.generateQI([CICP, CI.nsIObserver]),
  26.   
  27.     // The XPCOM events that require notification (separate registration process)
  28.     _xpcom_categories: [{
  29.             // After receiving this event, the component will initialize
  30.             category: "app-startup" 
  31.         }, {
  32.             // This event is used to intercept requests from within the browser (not the HTTP requests)
  33.             category: "content-policy"
  34.     }],
  35.  
  36.     /* Factory that creates a singleton instance of the component
  37.     [optional] custom factory (an object implementing nsIFactory). If not
  38.     provided, the default factory is used, which returns
  39.     |(new MyComponent()).QueryInterface(iid)| in its createInstance().
  40.     */
  41.     _xpcom_factory: {
  42.         createInstance : function() {
  43.             if (CsFireService.instance == null) {
  44.                 CsFireService.instance = new CsFireService();
  45.             }
  46.             return CsFireService.instance;
  47.         }
  48.     },
  49.  
  50.  
  51.     /*************************
  52.      * nsIObserver interface *
  53.      ************************/
  54.  
  55.     /*
  56.      * Handle notification messages
  57.      */
  58.     observe : function(subject, topic, data) {
  59.         switch (topic) {
  60.             // HTTP events
  61.             case "http-on-examine-response" :
  62.                 this.processHttpResponse(subject);
  63.                 break;
  64.             case "http-on-modify-request" :
  65.                 this.processHttpRequest(subject);
  66.                 break;
  67.  
  68.             // Application events
  69.             case "app-startup" :
  70.                 this.init();
  71.                 break;
  72.             case "xpcom-shutdown" :
  73.                 this.shutdown();
  74.                 break;
  75.         }
  76.     },
  77.     
  78.     /*
  79.      * Handle extension startup
  80.      */
  81.     init: function() {   
  82.         this.loadModules(); // No logging before this point :)
  83.  
  84.         CsFire.Logger.info("Starting CsFire");
  85.             
  86.         //Register observer
  87.         var os = CC['@mozilla.org/observer-service;1'].getService(CI.nsIObserverService);
  88.         os.addObserver(this, "http-on-modify-request", false);
  89.         os.addObserver(this, "http-on-examine-response", false);
  90.         os.addObserver(this, "xpcom-shutdown", false);
  91.     },
  92.     
  93.     /*
  94.      * Handle extension shut down
  95.      */
  96.     shutdown: function() {
  97.         var os = CC['@mozilla.org/observer-service;1'].getService(CI.nsIObserverService);
  98.         os.removeObserver(this, "http-on-modify-request");
  99.         os.removeObserver(this, "http-on-examine-response");
  100.         os.removeObserver(this, "xpcom-shutdown");
  101.     },
  102.     
  103.     /*
  104.     * Loads the required modules
  105.     *
  106.     * Note: if the module contains JavaScript errors, the resulting error will probably be "NS_ERROR_FILE_NOT_FOUND"!
  107.     */
  108.     loadModules : function() {
  109.         var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  110.         var resProt = ioService.getProtocolHandler("resource").QueryInterface(Components.interfaces.nsIResProtocolHandler);
  111.         var extensionDir = __LOCATION__.parent.parent; //retrieves the extension directory
  112.         var modulesDir = extensionDir.clone();
  113.         modulesDir.append("modules");
  114.         var resourceURI = ioService.newFileURI(modulesDir);
  115.         resProt.setSubstitution("csfiremodules", resourceURI);
  116.         
  117.         Components.utils.import("resource://csfiremodules/CsFireCommon.jsm");    
  118.  
  119.         CsFire.Logger.debug("Successfully loaded module dependencies");
  120.     },
  121.  
  122.     /*
  123.      * Processes an outgoing HTTP request, which means that data is collected,
  124.      * a policy decision is made and enforced.
  125.      */
  126.     processHttpRequest: function(subject) {
  127.         try {
  128.             subject.QueryInterface(Components.interfaces.nsIHttpChannel); 
  129.             
  130.             try {
  131.                 CsFire.CsFireController.registerHttpRequest(subject);
  132.                 CsFire.CsFireController.decideForURI(subject.URI, subject);
  133.             } 
  134.             catch(e2) {
  135.                 CsFire.Logger.error("Error processing request: " + e2);
  136.                 subject.cancel(Components.results.NS_BINDING_ABORTED);
  137.             }
  138.         } 
  139.         catch(e1) {
  140.             CsFire.Logger.error("Error processing request: not an HTTP channel? (" + e1 + ")");
  141.             subject.cancel(Components.results.NS_BINDING_ABORTED);
  142.         }
  143.     },
  144.     
  145.     /*
  146.      * Processes an HTTP response, which has an influence on requests requiring
  147.      * HTTP authentication.
  148.      */
  149.     processHttpResponse: function(subject) {
  150.         /* TODO Enable stripping of authentication headers
  151.          * Code is disabled due to bug 537670
  152.          * see https://bugzilla.mozilla.org/show_bug.cgi?id=537670
  153.          */
  154.         /*
  155.         try {
  156.             subject.QueryInterface(Components.interfaces.nsIHttpChannel); 
  157.             
  158.             try {
  159.                 CsFire.CsFireController.registerHttpResponse(subject);
  160.             } 
  161.             catch(e2) {
  162.                 CsFire.Logger.error("Error processing response: " + e2);
  163.                 subject.cancel(Components.results.NS_BINDING_ABORTED);
  164.             }
  165.         } 
  166.         catch(e1) {
  167.             CsFire.Logger.error("Error processing response: not an HTTP channel? (" + e1 + ")");
  168.             subject.cancel(Components.results.NS_BINDING_ABORTED);
  169.         }*/
  170.     },
  171.  
  172.     /******************************
  173.      * nsIContentPolicy interface *
  174.      *****************************/ 
  175.  
  176.     /*
  177.      * Implementation of the shouldLoad function. This function is called from the browser
  178.      * at the moment a new request is initiated (from the web page, address bar, ...). This 
  179.      * means that no HTTP data is available at this point (too soon).
  180.      */
  181.     shouldLoad: function(aContentType, aContentLocation, aRequestOrigin, aContext, aMimeTypeGuess, aExtra) {
  182.         CsFire.CsFireController.registerLoadRequest(aContentLocation, aRequestOrigin, aContentType, aContext);
  183.         // Accept by default: no decision can be made at this point
  184.         return CICP.ACCEPT;    
  185.     },
  186.  
  187.     /*
  188.      * Implementation of the shouldProcess function. Called after the information about
  189.      * the resource has been determined for sure. Not needed here, since this point is
  190.      * too late to prevent CSRF (resource has probably been partly loaded).
  191.      */
  192.     shouldProcess: function(aContentType, aContentLocation, aRequestOrigin, aContext, aMimeType, aExtra) {
  193.         return CICP.ACCEPT;
  194.     }
  195.  
  196. };
  197.  
  198.  
  199. var components = [CsFireService];
  200. function NSGetModule(compMgr, fileSpec) {
  201.   return XPCOMUtils.generateModule(components);
  202. }
  203.